Vetor
Toda variável no R é um vetor, um vetor pode visto como um conjunto de valores linear e homogêneo.
Para atribuir um valor à uma variável, utilizamos a seta <- indicando para onde estamos direcionando o valor.
É importante saber também, que para criar um vetor com valores, podemos utilizar a função c() que combina os valores em um vetor
Sendo assim, abaixo estamos criando a variável vetor e atribuindo o valor 1 5 4
vetor <- c(1, 5, 4)
vetor
Numéricos e Caracteres
No R tempos o conceito de tipos, onde cada valor tem um tipo específico, lembra das aulas de matemática sobre inteiros, decimais, etc?
Para verificar o tipo interpretado pelo R de um valor, podemos utilizar a função class(valor), onde valor é igual ao valor que você quer verificar.
class(5)
class("Olá mundo")
Reconhecendo tipos de variáveis
Veja que o R reconheceu o valor 5 como númerico e o texto “Olá mundo” como um conjunto de caracteres.
Isto também se aplica a variáveis, veja só:
variavel_numerica <- c(1,5,4,7)
variavel_caracteres <- c("Olá mundo")
class(variavel_numerica)
class(variavel_caracteres)
Também podemos usar as funções disponíveis em “is” para verificar os tipos, essa verificação retorna um tipo lógico para nós
variavel <- "5"
is.numeric(variavel)
is.character(variavel)
Lógicos
No R, também é possível criar tipos lógicos (verdadeiro ou falso)
logicos <- c(TRUE, FALSE, TRUE)
logicos2 <- c(T, F, T)
logicos
logicos2
class(logicos)
Veja que é possível abreviar as declarações.
Inteiros Explicitos
Você deve ter percebido que no caso do tipo numérico, o tipo não foi declarado explicitamente como inteiro, para fazer isso veja o próximo trecho:
inteiros <- c(1L, 2L, 3L)
inteiros
class(inteiros)
Gerar sequências no R é uma coisa muito fácil e divertida! Temos algumas formas para fazer isso:
#Gerando números de 1 a 10
1:10
#Gerando números de 10 a 1
10:1
#Gerando números de 100 a 120
seq(100, 120)
#Gerando 10 números a partir de 100
seq(100, length.out = 10)
#Gerando números de 10 a 20 de 2 em 2
seq.int(from = 10, to = 20, by = 2)
#Gerando 20 números
seq_len(20)
#Gerando um vetor do mesmo tamanho que o vetor passado
seq_along(c(70, 2))
#Repetindo o número 4 5 vezes
rep(4, times = 5)
NA, NaN, Inf, -Inf e NULL
Os tipos especiais são valores que possuem uma característica bem específica.
NA = Não disponível (Not Available) NaN = Não númerico (Not A Number) Inf = Infinito -Inf = -Infinito NULL = Vazio
Perceba que NA possui um tipo, mas NULL não, NULL representa o nada no caso do R e de diversas linguagens de programação.
Um detalhe é que não é possível colocar NULL em um vetor, ou seja, caso criemos um vetor com NULL, o R remove ele automáticamente
valor.na <- NA
valor.null <- NULL
valor.infinito <- Inf;
valor.menos.infinito <- -Inf
valor.nan <- NaN
vetor.com.null <- c(10,10,10,NULL)
vetor.com.null
[1] 10 10 10
No R é possível fazer operações aritméticas entre os valores disponíveis, abaixo teremos exemplos para algumas operações aritméticas simples:
# Adição
adicao <- 5+5
adicao
# Subtração
subtracao <- 5-5
subtracao
# Multiplicação
multiplicao <- 5*5
multiplicao
# Divisão
divisao <- 5/5
divisao
#Raiz Quadrada
raiz <- sqrt(10)
raiz
#Numero imaginário
numero <- 1i
numero
Operações com vetores
As operações aritméticas se estendem a vetores também, veja abaixo um exemplo:
# Vetor de dez posições
vetor <- c(1:10)
vetor * 2
# Veja que obtemos o dobro de cada valor do vetor, isso se aplica para todas as operações.
Fatores
Através de fatores, é possível classificar dados para que as máquinas consigam processar com mais facilidade. Veja que no output, o R escreve “Levels: Feminino Masculino” para identificar as classes encontradas.
sexo <- c("Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino")
fatorado <- as.factor(sexo);
fatorado
[1] Feminino Masculino Feminino Masculino Feminino Masculino Feminino Masculino
[9] Feminino Masculino
Levels: Feminino Masculino
Listas
No R, temos o tipo de lista onde é possível armazenar vetores com tipos diferentes:
v1 <- c(1, 2, 3);
v2 <- c(T, F, T);
v3 <- c("a", "b", "c");
lista <- list(v1, v2, v3)
class(lista)
lista
Matrizes
Matrizes são um conjunto de valores distribuídos em linhas e colunas. A visualização abaixo deve esclarecer melhor:
matriz <- matrix(ncol = 5, nrow = 5, data = 1:5)
matriz
Você deve ter percebido que também é possível atribuir uma matriz para uma variável com esse exemplo.
Vamos a um exemplo de operação com matrizes
matrizA <- matrix(ncol = 5, nrow = 5, data = 1:5)
matrizB <- matrix(ncol = 5, nrow = 5, data = 1:5)
# Esta operação abaixo não é uma multiplicação de matrizes, é apenas uma multiplicação de valores.
matriz <- matrizA * matrizB
matriz
[,1] [,2] [,3] [,4] [,5]
[1,] 1 1 1 1 1
[2,] 4 4 4 4 4
[3,] 9 9 9 9 9
[4,] 16 16 16 16 16
[5,] 25 25 25 25 25
Para fazermos uma multiplicaçáo de matrizes, precisamos seguir uma regra: a quantidade de colunas da matriz A deve ser equivalente a quantidade de linhas da matriz B.
Abaixo um exemplo de multiplicação de matrizes:
linhas <- 5
colunas <- 10
matrizA <- matrix(ncol = linhas, nrow = colunas, data = 1:2)
matrizB <- matrix(ncol = colunas, nrow = linhas, data = 1:2)
matrizA %*% matrizB
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] 7 8 7 8 7 8 7 8 7 8
[2,] 14 16 14 16 14 16 14 16 14 16
[3,] 7 8 7 8 7 8 7 8 7 8
[4,] 14 16 14 16 14 16 14 16 14 16
[5,] 7 8 7 8 7 8 7 8 7 8
[6,] 14 16 14 16 14 16 14 16 14 16
[7,] 7 8 7 8 7 8 7 8 7 8
[8,] 14 16 14 16 14 16 14 16 14 16
[9,] 7 8 7 8 7 8 7 8 7 8
[10,] 14 16 14 16 14 16 14 16 14 16
Funções úteis para matrizes
matrizA <- matrix(ncol = 2, nrow = 2, data = 1:4)
print("Dimensões da matriz - Linhas x Colunas")
[1] "Dimensões da matriz - Linhas x Colunas"
dim(matrizA) #inversa, esta deve ser quadrada
[1] 2 2
print("Transposta")
[1] "Transposta"
t(matrizA) #transposta
[,1] [,2]
[1,] 1 2
[2,] 3 4
print("Identidade")
[1] "Identidade"
diag(matrizA) #identidade
[1] 1 4
print("Inversa")
[1] "Inversa"
solve(matrizA) #inversa, esta deve ser quadrada
[,1] [,2]
[1,] -2 1.5
[2,] 1 -0.5
matrizA <- cbind(matrizA, c(5,2)) #Adiciona colunas no fim da matriz
#Colunas adicionadas
print("Colunas adicionadas")
[1] "Colunas adicionadas"
matrizA
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 2
print("Linhas adicionadas")
[1] "Linhas adicionadas"
matrizA <- rbind(matrizA, c(5,2, 3))
matrizA
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 2
[3,] 5 2 3
Data Frame
Criar um dataframe é bem simples, veja:
vetorA <- c(1,5,4,7)
vetorB <- c("Olá mundo")
dataframe <- data.frame(vetorA, vetorB)
# Colocando nomes nas colunas
colnames(dataframe) <- c("Numérico", "Texto")
dataframe
O mais legal do dataframe, é que conseguimos colocar dados heterogêneos, ao contrário dos vetores e matrizes.
Também é possível criar um dataframe a partir de uma lista:
lista <- list(c(1,2), c(T,F), c("teste", "teste2"))
dataframe <- data.frame(lista)
dataframe
Datas
Geralmente o trabalho com datas é uma das coisas mais complexas em programação. Vamos ver aqui algumas funções que o R disponibiliza para nós:
data.texto = "13/11/2018 T 19:10:00"
data.date = as.Date(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time1 = as.POSIXct(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time2 = as.POSIXlt(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time1
[1] "2018-11-13 19:10:00 -02"
data.time2
[1] "2018-11-13 19:10:00 -02"
data.date
[1] "2018-11-13"
Através do método unclass, podemos ver o conteúdo real de uma variável, suas propriedades e etc. Quando passamos data.date para a função unclass, obtemos a quantidade de dias desde 01/01/1970 até a data da variável.
unclass(data.date)
[1] 17848
No caso de time1 e time2 veja que não temos diferenças no texto, entretanto veja quando fazemos o unclass.
print("Time1")
[1] "Time1"
unclass(data.time1)
[1] 1542143400
attr(,"tzone")
[1] "America/Sao_Paulo"
print("Time2")
[1] "Time2"
unclass(data.time2)
$`sec`
[1] 0
$min
[1] 10
$hour
[1] 19
$mday
[1] 13
$mon
[1] 10
$year
[1] 118
$wday
[1] 2
$yday
[1] 316
$isdst
[1] 1
$zone
[1] "-02"
$gmtoff
[1] NA
attr(,"tzone")
[1] "America/Sao_Paulo"
O unclass no time1 retorna a contagem em segundos desde 01/01/1970 até a data da variável!!
Para obter a data atual
Sys.Date()
[1] "2018-12-01"
Lubridate
Lubridate é um pacote disponibilizado para manipular datas no R. Para instalar e carregar:
install.packages("lubridate")
Installing package into <U+393C><U+3E31>C:/Users/sergio.prates/Documents/R/win-library/3.5<U+393C><U+3E32>
(as <U+393C><U+3E31>lib<U+393C><U+3E32> is unspecified)
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.5/lubridate_1.7.4.zip'
Content type 'application/zip' length 1568280 bytes (1.5 MB)
downloaded 1.5 MB
package lubridate successfully unpacked and MD5 sums checked
The downloaded binary packages are in
C:\Users\sergio.prates\AppData\Local\Temp\RtmpgpS10z\downloaded_packages
library(lubridate)
Attaching package: <U+393C><U+3E31>lubridate<U+393C><U+3E32>
The following object is masked from <U+393C><U+3E31>package:base<U+393C><U+3E32>:
date
O lubridate fornece funções que retornarão a data no formato solicitado e além disso ele trabalha com o conceito de duração.
segundos = dseconds(260)
minutos = dminutes(260)
anos = dyears(260)
duration(10, units = "seconds")
[1] "10s"
segundos
[1] "260s (~4.33 minutes)"
minutos
[1] "15600s (~4.33 hours)"
anos
[1] "8199360000s (~259.82 years)"
#abaixo as funções de data
#Ano mes dia
data <- ymd("20190101")
# Dia mes ano hora
dmy_h("1110201810")
[1] "2018-10-11 10:00:00 UTC"
# Retorna o dia da semana
wday(data, label = T)
[1] Tue
Levels: Sun < Mon < Tue < Wed < Thu < Fri < Sat
Para tomar algumas decisões durante a execução de código, o R fornece algumas estruturas de controle.
souBonito <- TRUE
if (souBonito) {
print("Eu Sei")
} else {
print("Vish")
}
[1] "Eu Sei"
souBonito <- F
ifelse(souBonito, "verdade", "falso")
[1] "falso"
Estruturas de controle são muito úteis quando você precisa testar algum tipo de condição, se alguma compra foi realizada por exemplo, ou se algo ocorreu.
Loops são utilizados quando precisamos por exemplo repetir um conjunto de instruções para determinados itens.
itens <- c(10,20,30)
for (variable in itens) {
print(variable)
}
[1] 10
[1] 20
[1] 30
Veja que escrevemos todos os itens do vetor na tela, podemos utilizar para consolidar informações e enfim, para qualquer conjunto de instruções que precise se repetir.
Vamos montar um dataframe com um loop
vetor <- 1:10
acumulado <- 0
tabela <- data.frame();
for (variable in vetor) {
acumulado <- variable + acumulado
tabela <- rbind(tabela, c(variable, acumulado))
}
colnames(tabela) <- c("Valor1", "Acumulado")
tabela
Funções são utilizadas quando queremos reaproveitar algum trecho de código específico. por exemplo, digamos que precisamos calcular o enesimo termo de uma Progressão Aritmética
primeiro.termo <- 1
razao<- 2
obter.termo.pa <- function(primeiro.termo, numero.termo, razao) {
return(primeiro.termo + (numero.termo - 1) * razao)
}
obter.termo.pa(primeiro.termo, 50, razao)
[1] 99
Em funções, podemos receber reticências como parametro, que significa que podemos receber N parametros na função. Um exemplo de função assim é a função paste.
concatena <- function(...) {
c <- paste(...)
c
}
concatena("Sergio", "Prates")
[1] "Sergio Prates"
No R possuimos a função sample para randomizar a ocorrência de determinados valores
# Letras de a até g
amostra1 <- letters[1:7]
# Letras de A até D
amostra2 <- LETTERS[1:4]
# Pode repetir as ocorrências
sample(x = amostra1, size = 20, replace = T)
[1] "a" "d" "f" "a" "e" "a" "g" "d" "d" "e" "e" "b" "d" "g" "a" "a" "d" "e" "c" "c"
# Não pode repetir as ocorrências
sample(x = amostra2, size = 3, replace = F)
[1] "C" "D" "A"
Para garantir que sempre o mesmo resultado aconteça, podemos utilizar a função set.seed com um valor fixo
set.seed(1)
sample(x = amostra1, size = 20, replace = T)
[1] "b" "c" "e" "g" "b" "g" "g" "e" "e" "a" "b" "b" "e" "c" "f" "d" "f" "g" "c" "f"
O R nos fornecea alguns comandos para gerar dados aleatórios, sendo eles da família normal, binomial e uniforme.
Os comandos da familia normal possuem norm no final, os binomiais possuem binom e assim por diante… Veja abaixo exemplos:
set.seed(18) #garantindo que sempre sairá o mesmo resultado
# sd representa o desvio padrão dos dados
print("rnorm")
[1] "rnorm"
rnorm(n=10, mean=0, sd=1)
[1] 0.92645924 1.82282117 -1.61056690 -0.28510975 -0.34207303 0.36617615
[7] -1.32704085 2.41259221 0.06381535 1.54551478
print("dnorm")
[1] "dnorm"
dnorm(x = 1:10, mean = 0, sd = 1)
[1] 2.419707e-01 5.399097e-02 4.431848e-03 1.338302e-04 1.486720e-06 6.075883e-09
[7] 9.134720e-12 5.052271e-15 1.027977e-18 7.694599e-23
print("pnorm")
[1] "pnorm"
pnorm( q = 1:10, mean = 0, sd = 1)
[1] 0.8413447 0.9772499 0.9986501 0.9999683 0.9999997 1.0000000 1.0000000 1.0000000
[9] 1.0000000 1.0000000
print("rbinom")
[1] "rbinom"
rbinom(size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1), n = 10)
[1] 0 0 1 1 0 1 7 8 9 10
print("dbinom")
[1] "dbinom"
dbinom(size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1), x = 1:10)
[1] 1e-01 1e-02 1e-03 1e-04 1e-05 1e-06 1e+00 1e+00 1e+00 1e+00
print("pbinom")
[1] "pbinom"
pbinom(q = 1:10, size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1))
[1] 1 1 1 1 1 1 1 1 1 1
print("Distribuição de poison")
[1] "Distribuição de poison"
rpois(100, 5)
[1] 5 5 3 4 8 5 3 3 3 6 8 5 6 5 2 2 7 1 3 5 3 3 6 6 1 4 3
[28] 7 5 5 4 2 1 3 3 6 5 12 6 7 8 4 2 10 7 4 6 5 2 3 6 5 7 5
[55] 6 6 11 5 6 7 7 4 5 3 6 6 7 4 2 6 4 6 4 6 3 4 3 7 6 13 4
[82] 3 5 3 1 4 3 5 8 8 5 6 6 6 3 6 5 3 2 1
Para fazer plots, ou gráficos em R podemos utilizar a função plot()
plot(x = cars$speed, y = cars$dist, type = "p", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")
plot(x = cars$speed, y = cars$dist, type = "l", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")
plot(x = cars$speed, y = cars$dist, type = "h", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")
Podemos utilizar a equação abaixo para plotar um gráfico linear \(y = \beta_0 + \beta_1 + \epsilon\)
Onde
\(\beta_0 = 0,5\)
\(\beta_1 = 2,0\)
\(x\sim N(0;1²)\)
\(\epsilon\sim N(0;2²)\)
#install.packages('plotly')
library(plotly)
set.seed(5)
x = rnorm(n=350, mean=0, sd=1)
e = rnorm(n=350, mean=0, sd=2)
y=0.5 + 2*x + e
plot(x=x, y=y)
plot_ly(x=x, y=y, type="scatter", mode="markers")
Com a função download file podemos baixar arquivos da web, neste caso ele sempre trata como texto os dados.
baixar <- function(url) {
#Cria a pasta caso não exista
if(!file.exists('data')){
dir.create('data')
}
file.url = url
file.local = file.path('./data', basename(file.url))
download.file(url = file.url, destfile = file.local , mode='wb')
}
baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas.csv')
baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas-Partidas.csv')
baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas-Jogadores.csv')
baixar('https://github.com/elthonf/fiap-mba-r/raw/master/data/cameras.baltimore.xlsx')
Para ler dados de csvs podemos utilizar a função read.csv
copas <- read.csv('./data/Copas.csv', header = T)
copas
Para ler dados do excel, podemos utilizar o pacote
install.packages('readxl')
Installing package into <U+393C><U+3E31>C:/Users/sergio.prates/Documents/R/win-library/3.5<U+393C><U+3E32>
(as <U+393C><U+3E31>lib<U+393C><U+3E32> is unspecified)
also installing the dependencies <U+393C><U+3E31>rematch<U+393C><U+3E32>, <U+393C><U+3E31>cellranger<U+393C><U+3E32>
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.5/rematch_1.0.1.zip'
Content type 'application/zip' length 15994 bytes (15 KB)
downloaded 15 KB
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.5/cellranger_1.1.0.zip'
Content type 'application/zip' length 103141 bytes (100 KB)
downloaded 100 KB
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.5/readxl_1.1.0.zip'
Content type 'application/zip' length 1499856 bytes (1.4 MB)
downloaded 1.4 MB
package rematch successfully unpacked and MD5 sums checked
package cellranger successfully unpacked and MD5 sums checked
package readxl successfully unpacked and MD5 sums checked
The downloaded binary packages are in
C:\Users\sergio.prates\AppData\Local\Temp\RtmpOqvMmO\downloaded_packages
library(readxl)
O pacote dplyr nos ajuda a manipular estruturas de tabelas de maneira bastante eficiente.
Abaixo utilizamos o pipe para passar o conteúdo
install.packages('dplyr')
Error in install.packages : Updating loaded packages
library(dplyr)
Attaching package: <U+393C><U+3E31>dplyr<U+393C><U+3E32>
The following objects are masked from <U+393C><U+3E31>package:stats<U+393C><U+3E32>:
filter, lag
The following objects are masked from <U+393C><U+3E31>package:base<U+393C><U+3E32>:
intersect, setdiff, setequal, union